home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 June: Reference Library / Dev.CD Jun 94.toast / What's New? / Tool Chest / ColorSync™ 1.0.5 / Dummy CMM / DummyCMM.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-11  |  4.9 KB  |  204 lines  |  [TEXT/KAHL]
  1. /*
  2. ** Color Matching Method (CMM) Component Shell
  3.  
  4.     93.06.26    tem        Fix version returned by ComponentVersion(…)
  5.                         Rework ComponentCanDo(…)
  6.  
  7. */
  8.  
  9. #include <QuickDraw.h>
  10. #include <Components.h>
  11. #include <CMComponent.h>
  12. #include <CMApplication.h>
  13. #include <Memory.h>
  14.  
  15. /* Prototypes of CMS component routines */
  16.  
  17. pascal CMError    ComponentOpen(Handle storage, ComponentInstance self);
  18. pascal CMError    ComponentClose(Handle storage, ComponentInstance self);
  19. pascal long     ComponentCanDo(Handle storage, short selector);
  20. pascal long     ComponentVersion(Handle storage); 
  21. pascal CMError    CMMInit( Handle storage, CMProfileHandle srcProfile, CMProfileHandle dstProfile);
  22. pascal CMError    CMMMatchColors( Handle storage, CMColorList myColors, long count );
  23. pascal CMError    CMMGamutTest( Handle storage, CMColorList myColors, long count, CMGamutResult result );
  24.  
  25.  
  26.  
  27. #define     CMCodeVersion                1
  28.  
  29. /* Build a code resource */
  30. #define realthing
  31.  
  32. #ifdef realthing
  33. pascal ComponentResult main( ComponentParameters *params, Handle storage )
  34. #else
  35. pascal ComponentResult CMM( ComponentParameters *params, Handle storage )
  36. #endif
  37. {
  38.     ComponentFunction    routineToCall = 0; 
  39.     short                message = params->what;        
  40.     CMError                result;
  41.  
  42.     if (message < 0) {
  43.         switch (message) {
  44.             case kComponentOpenSelect          : routineToCall = (ComponentFunction)ComponentOpen;
  45.                                               break; 
  46.             case kComponentCloseSelect      : routineToCall = (ComponentFunction)ComponentClose; 
  47.                                               break; 
  48.             case kComponentCanDoSelect      : routineToCall = (ComponentFunction)ComponentCanDo; 
  49.                                               break; 
  50.             case kComponentVersionSelect     : routineToCall = (ComponentFunction)ComponentVersion;
  51.             default                         : return (noErr);
  52.         }
  53.     }
  54.     else {
  55.         switch (message) {
  56.              case kCMInit                     : routineToCall = (ComponentFunction)CMMInit;        
  57.                                               break; 
  58.             case kCMMatchColors                 : routineToCall = (ComponentFunction)CMMMatchColors;    
  59.                                               break; 
  60.             case kCMGamutTest                 : routineToCall = (ComponentFunction)CMMGamutTest;    
  61.                                               break; 
  62.             default                         : return (CMUnimplementedError);
  63.         }
  64.     };
  65.     
  66.      result = CallComponentFunctionWithStorage(storage, params, routineToCall); 
  67.  
  68.      return result;
  69. }
  70.  
  71. pascal CMError ComponentOpen(Handle storage, ComponentInstance self) 
  72. { 
  73.     Handle myStorage; /* allocate dummy handle for private storage */ 
  74.  
  75.     myStorage = (Handle) NewHandle( sizeof( long ) ); 
  76.     SetComponentInstanceStorage( self, myStorage ); 
  77.     return( noErr ); 
  78. }
  79.  
  80. /* This is the DisposeMatchData call -- Clean up private storage */
  81. pascal CMError ComponentClose(Handle storage, ComponentInstance self) 
  82. { 
  83.     DisposHandle( storage );
  84.     return( noErr ); 
  85. }
  86.  
  87. pascal long ComponentCanDo(Handle storage, short selector)
  88. {
  89.     long    result;
  90.     
  91.     switch (selector)
  92.     {
  93.         /* Component Manager selectors */
  94.         case kComponentOpenSelect:
  95.         case kComponentCloseSelect:
  96.         case kComponentCanDoSelect:
  97.         case kComponentVersionSelect:
  98.             result = true;
  99.             break;
  100.         case kComponentRegisterSelect:
  101.         case kComponentTargetSelect:
  102.             result = false;
  103.             break;
  104.         
  105.         /* CMM Component selectors */
  106.         case kCMInit:
  107.         case kCMMatchColors:
  108.         case kCMGamutTest:
  109.             result = true;
  110.             break;
  111.             
  112.         case kCMMatchPixMap:
  113.         case kCMCheckPixMap:
  114.         case kCMConcatenateProfiles:
  115.             result = false;
  116.             break;
  117.         
  118.         default:
  119.             result = false;
  120.             break;
  121.     }
  122.  
  123.     return (result);
  124. }
  125.  
  126. pascal long ComponentVersion(Handle storage) 
  127. {
  128.     /* interface version in hi word, */ 
  129.     /* code rev in lo word  */ 
  130.     return(((CMInterfaceVersion << 16) | CMCodeVersion));      
  131. }
  132.  
  133. pascal CMError CMMInit( Handle storage, CMProfileHandle src, CMProfileHandle dst )
  134. {
  135.     /* Do something intelligent here, like fill out storage with conversion info */
  136.  
  137.     if( (**dst).header.size == sizeof(CMHeader) )
  138.         **storage = 0L;
  139.     else
  140.         **storage = 0xffffffffL;    /* flag matching should occur */        
  141.         
  142.     return( noErr );
  143. } 
  144.  
  145.  
  146. pascal CMError CMMMatchColors( Handle storage, CMColorList myColors, long count )
  147. {
  148.     long         iii;
  149.     CMError        error;
  150.     long        index;
  151.     RGBColor    *myColorPtr;    /* A real CMM would use CMColor* */
  152.  
  153.     if( **storage )    /* only match if flagged */
  154.     {
  155.         for (iii=0; iii<count; iii++)
  156.         {
  157.             myColorPtr = (RGBColor *)(((char *)myColors) + (iii<<3));
  158.             
  159.             /* Just invert the RGB components */
  160.             (*myColorPtr).red = ~(*myColorPtr).red;
  161.             (*myColorPtr).green = ~(*myColorPtr).green;
  162.             (*myColorPtr).blue = ~(*myColorPtr).blue;
  163.         }
  164.     }
  165.  
  166.     return( noErr );
  167. } 
  168.  
  169.  
  170. pascal CMError CMMGamutTest( Handle storage, CMColorList myColors, long count, CMGamutResult result )
  171. {
  172.     unsigned long    mask;
  173.     long            dstLong;
  174.     long             iii;
  175.     RGBColor        *myColorPtr;    /* A real CMM would use CMColor* */
  176.  
  177.     /* Fill out CMGamutResult bit-field.  */
  178.  
  179.     mask = 0x80000000;
  180.     dstLong = 0;
  181.     for (iii=0; iii<count; iii++)
  182.     {
  183.         myColorPtr = (RGBColor *)(((char *)myColors) + (iii<<3));
  184.         
  185.         if( (*myColorPtr).red >= 0x8000 )
  186.         {
  187.             dstLong |= mask;
  188.         }
  189.         mask >>= 1;
  190.         if( !mask )
  191.         {
  192.             mask = 0x80000000;
  193.             *result++ = dstLong;
  194.             dstLong = 0;
  195.         }
  196.     }
  197.     if (mask != 0x80000000)
  198.             *result = dstLong;
  199.  
  200.     return( noErr );
  201. } 
  202.  
  203.  
  204.